//#include "detector.h"

//Detector::Detector()
//{
//    _capture.open(0);
//    _capture.set(CV_CAP_PROP_FRAME_WIDTH, 640);
//    _capture.set(CV_CAP_PROP_FRAME_HEIGHT, 480);
//    _capture >> _frame;
//    _frame.copyTo(_oldframe);
//    f = new ForegroundExtractor(_frame.rows,_frame.cols, 5, 32, false);
//}

//Detector::~Detector()
//{
//    _capture.release();
//}

//QImage Detector::getFrame()
//{
//    Mat diff, ave, rai;
//    static int count = 0;
//    count++;
//    _capture >> _frame;
//    //        sobel(_frame,4,0);
//    //    laplacian(_frame);
//    //    contrast(_frame,8,0);
//    //    GaussianBlur(_frame,_frame,Size(3,3),1.5,1.5);
//    //    traitement(_frame);

//    cvtColor(_frame,_frame,CV_BGR2GRAY);
//    bool _threshold = true;
//    f->runningAverageImage(rai);
//    f->difference(rai,_frame,diff);

//    f->update(_frame);
//    f->addDifferenceFrame(diff);
//    f->differenceRunningAverage(ave);
//    if(_threshold) {
//        threshold(ave,ave,8,255,CV_THRESH_BINARY);
//        threshold(diff,diff,32,255,CV_THRESH_BINARY);
//    }
//    _frame.copyTo(_oldframe);

////    for( int y = 0; y < _frame.rows; y++ ) {
////        for( int x = 0; x < _frame.cols; x++ ) {
////            if(_threshold) {
////                if(diff.at<uchar>(y,x) != 255) {
////                    _frame.at<Vec3b>(y,x)[0]  = 0;
////                    _frame.at<Vec3b>(y,x)[1]  = 0;
////                    _frame.at<Vec3b>(y,x)[2]  = 0;
////                }
////            }
////            else{
////                //                _frame.at<Vec3b>(y,x)[0]  *= ave.at<uchar>(y,x) / 255.0;
////                //                _frame.at<Vec3b>(y,x)[1]  *= ave.at<uchar>(y,x) / 255.0;
////                //                _frame.at<Vec3b>(y,x)[2]  *= ave.at<uchar>(y,x) / 255.0;
////                _frame.at<Vec3b>(y,x)[0]  *= diff.at<uchar>(y,x) / 255.0;
////                _frame.at<Vec3b>(y,x)[1]  *= diff.at<uchar>(y,x) / 255.0;
////                _frame.at<Vec3b>(y,x)[2]  *= diff.at<uchar>(y,x) / 255.0;
////            }
////        }
////    }
////        cvtColor(_frame,_frame,CV_BGR2GRAY);
//    //    extendDynamicly<uchar,3>(_frame,_frame);

//    //    cvtColor(_frame,_frame,CV_BGR2GRAY);
//    //    f->difference(_oldframe,_frame,diff);
//    //    _frame.copyTo(_oldframe);
//    return  mat2QImage(diff);
//}





//void Detector::traitement(Mat &value) const
//{
//    Mat kern = (Mat_<char>(3,3) <<
//                0, -1 , 0,
//                -1,  4, -1,
//                0, -1 , 0);
//    Mat copie;
//    denoise(value,copie);
//    cvtColor(copie,value,CV_BGR2GRAY);
//    filter2D(value,value,0,kern);
//}

//void Detector::colorTraitement(Mat &value) const
//{
//    Mat copie;
//    denoise(value,copie);
//    colorGradient(value,value);
//    contrast(value,8.0,0);
//}

//void Detector::colorGradient(const Mat &image, Mat &gradient) const
//{
//    cvtColor(image,image,CV_BGR2HSV);
//    cvtColor(image,gradient,CV_BGR2GRAY);
//    for( int y = 1; y < (gradient.rows - 1); y++ )
//        for( int x = 1; x < (gradient.cols - 1); x++ )
//            gradient.at<uchar>(y,x) = saturate_cast<uchar>(
//                        (  distance(image.at<Vec3b>(y,x),image.at<Vec3b>(y,x+1))
//                           + distance(image.at<Vec3b>(y,x),image.at<Vec3b>(y,x-1))
//                           + distance(image.at<Vec3b>(y,x),image.at<Vec3b>(y+1,x))
//                           + distance(image.at<Vec3b>(y,x),image.at<Vec3b>(y-1,x))) / 4.0f);
//}


//void Detector::denoise(const Mat &input, Mat &output) const
//{
//    Mat L,a,b;
//    cvtColor(input, output, CV_BGR2Lab);

//    cvtColor(output, L, CV_BGR2GRAY);
//    cvtColor(output, a, CV_BGR2GRAY);
//    cvtColor(output, b, CV_BGR2GRAY);

//    for( int y = 0; y < output.rows; y++ ) {
//        for( int x = 0; x < output.cols; x++ ) {
//            L.at<uchar>(y,x)  = output.at<Vec3b>(y,x)[0];
//            a.at<uchar>(y,x)  = output.at<Vec3b>(y,x)[1];
//            b.at<uchar>(y,x)  = output.at<Vec3b>(y,x)[2];
//        }
//    }
//    GaussianBlur(L, L, Size(3,3), 1.5, 1.5);
//    GaussianBlur(a, a, Size(3,3), 1.5, 1.5);
//    GaussianBlur(b, b, Size(3,3), 1.5, 1.5);

//    for( int y = 0; y < output.rows; y++ ) {
//        for( int x = 0; x < output.cols; x++ ) {
//            output.at<Vec3b>(y,x)[0]  = L.at<uchar>(y,x);
//            output.at<Vec3b>(y,x)[1]  = a.at<uchar>(y,x);
//            output.at<Vec3b>(y,x)[2]  = b.at<uchar>(y,x);
//        }
//    }

//    cvtColor(output, output, CV_Lab2BGR);
//}

//void Detector::toLab(const Mat &input, Mat &output) const
//{
//    static Mat L = Mat::zeros( input.size(), CV_8U );
//    static Mat a = Mat::zeros( input.size(), CV_8U );
//    static Mat b = Mat::zeros( input.size(), CV_8U);

//    cvtColor(input, output, CV_BGR2Lab);

//    for( int y = 0; y < output.rows; y++ ) {
//        for( int x = 0; x < output.cols; x++ ) {
//            L.at<uchar>(y,x)  = output.at<Vec3b>(y,x)[0];
//            a.at<uchar>(y,x)  = output.at<Vec3b>(y,x)[1];
//            b.at<uchar>(y,x)  = output.at<Vec3b>(y,x)[2];
//        }
//    }

//    Mat kern = (Mat_<char>(3,3) <<
//                0, -1 , 0,
//                -1,  5, -1,
//                0, -1 , 0);

//    GaussianBlur(a, a, Size(3,3), 1.5, 1.5);
//    GaussianBlur(b, b, Size(3,3), 1.5, 1.5);

//    halfContrast(a,2.0,1.0,24);
//    halfContrast(b,2.0,1.0,24);

//    GaussianBlur(L, L, Size(3,3), 1.5, 1.5);
//    filter2D(L,L,0,kern);
//    contrast(L,1.0,0);

//    for( int y = 0; y < output.rows; y++ ) {
//        for( int x = 0; x < output.cols; x++ ) {
//            output.at<Vec3b>(y,x)[0]  = L.at<uchar>(y,x);
//            output.at<Vec3b>(y,x)[1]  = a.at<uchar>(y,x);
//            output.at<Vec3b>(y,x)[2]  = b.at<uchar>(y,x);
//        }
//    }

//    cvtColor(output, output, CV_Lab2BGR);
//}

//void Detector::contrast(Mat &input, double alpha, int beta) const
//{
//    for( int y = 0; y < input.rows; y++ )
//        for( int x = 0; x < input.cols; x++ )
//            input.at<uchar>(y,x) =saturate_cast<uchar>( alpha*( input.at<uchar>(y,x) ) + beta );
//}

//void Detector::halfContrast(Mat &input, float alpha, float beta, float offset) const
//{
//    float bsup = 127.0 + offset;
//    float binf = 127.0 - offset;
//    for( int y = 0; y < input.rows; y++ ) {
//        for( int x = 0; x < input.cols; x++ ) {
//            if(input.at<uchar>(y,x) > bsup)
//                input.at<uchar>(y,x) =saturate_cast<uchar>(bsup + (input.at<uchar>(y,x) - bsup) * alpha);
//            else if(input.at<uchar>(y,x) > 127)
//                input.at<uchar>(y,x) =qMax(saturate_cast<uchar>(bsup - (bsup - input.at<uchar>(y,x)) * beta),(uchar)127);
//            else if(input.at<uchar>(y,x) > binf)
//                input.at<uchar>(y,x) =qMin(saturate_cast<uchar>(binf + (input.at<uchar>(y,x) - binf) * beta),(uchar)127);
//            else
//                input.at<uchar>(y,x) =saturate_cast<uchar>(binf - (binf - input.at<uchar>(y,x)) * alpha);
//        }
//    }
//}

//void Detector::labGradient(Mat &value) const
//{
//    static Mat L = Mat::zeros( value.size(), CV_8U);
//    static Mat a = Mat::zeros( value.size(), CV_8U);
//    static Mat b = Mat::zeros( value.size(), CV_8U);
//    static Mat kern = (Mat_<char>(3,3) <<
//                       0, -1 , 0,
//                       -1,  4, -1,
//                       0, -1 , 0);

//    cvtColor(value, value, CV_BGR2Lab);

//    for( int y = 0; y < value.rows; y++ ) {
//        for( int x = 0; x < value.cols; x++ ) {
//            L.at<uchar>(y,x)  = value.at<Vec3b>(y,x)[0];
//            a.at<uchar>(y,x)  = value.at<Vec3b>(y,x)[1];
//            b.at<uchar>(y,x)  = value.at<Vec3b>(y,x)[2];
//        }
//    }

//    GaussianBlur(L, L, Size(3,3), 1.5, 1.5);

//    filter2D(L,L,0,kern);
//    filter2D(a,a,0,kern);
//    filter2D(b,b,0,kern);

//    threshold(a,a,7,255, CV_THRESH_TOZERO);
//    threshold(b,b,7,255, CV_THRESH_TOZERO);

//    GaussianBlur(a, a, Size(3,3), 1.0, 1.0);
//    GaussianBlur(b, b, Size(3,3), 1.0, 1.0);

//    //    contrast(a,4,0);
//    //    contrast(b,4,0);
//    //    contrast(L,4,0);

//    cvtColor(value, value, CV_BGR2GRAY);

//    for( int y = 0; y < value.rows; y++ )
//        for( int x = 0; x < value.cols; x++ )
//            value.at<uchar>(y,x) = saturate_cast<uchar>(qMax(qMax( L.at<uchar>(y,x) , a.at<uchar>(y,x)), b.at<uchar>(y,x)));

//    //    threshold(value,value, 15,255, CV_THRESH_TOZERO);
//    //    contrast(value,4,0);
//    //    fastNlMeansDenoising(value,value,3,3,21);

//}


//void Detector::rgbGradient(Mat &value) const
//{
//    static Mat b = Mat::zeros( value.size(), CV_8U );
//    static Mat g = Mat::zeros( value.size(), CV_8U );
//    static Mat r = Mat::zeros( value.size(), CV_8U);
//    static Mat kern = (Mat_<char>(3,3) <<
//                       0, -1 , 0,
//                       -1,  4, -1,
//                       0, -1 , 0);

//    for( int y = 0; y < value.rows; y++ ) {
//        for( int x = 0; x < value.cols; x++ ) {
//            b.at<uchar>(y,x)  = value.at<Vec3b>(y,x)[0];
//            g.at<uchar>(y,x)  = value.at<Vec3b>(y,x)[1];
//            r.at<uchar>(y,x)  = value.at<Vec3b>(y,x)[2];
//        }
//    }

//    GaussianBlur(b, b, Size(3,3), 1.5, 1.5);
//    GaussianBlur(r, r, Size(3,3), 1.5, 1.5);
//    GaussianBlur(g, g, Size(3,3), 1.5, 1.5);

//    filter2D(b,b,0,kern);
//    filter2D(g,g,0,kern);
//    filter2D(r,r,0,kern);

//    cvtColor(value, value, CV_BGR2GRAY);

//    for( int y = 0; y < value.rows; y++ )
//        for( int x = 0; x < value.cols; x++ )
//            value.at<uchar>(y,x) = saturate_cast<uchar>(qMax(qMax(b.at<uchar>(y,x), g.at<uchar>(y,x)), r.at<uchar>(y,x)));

//}

//void Detector::sobel(Mat &value, int sigma, int threshold) const
//{
//    Mat sX;
//    Mat sY;
//    Mat kernX = (Mat_<char>(3,3) <<
//                 -1,  0 , 1,
//                 -2 * sigma,  0,  2 * sigma,
//                 -1, -0 , 1);
//    Mat kernY = (Mat_<char>(3,3) <<
//                 1,  2 * sigma,  1,
//                 0,  0,  0,
//                 -1, -2 * sigma, -1);
//    cvtColor(value,sX,CV_BGR2GRAY);
//    cvtColor(value,sY,CV_BGR2GRAY);
//    filter2D(sX,sX,0,kernX,Point(-1,-1),127);
//    filter2D(sY,sY,0,kernY,Point(-1,-1),127);
//    cvtColor(value,value,CV_BGR2GRAY);
//    for( int y = 0; y < value.rows; y++ )
//        for( int x = 0; x < value.cols; x++ )
//            value.at<uchar>(y,x) = saturate_cast<uchar>( sqrt( (sX.at<uchar>(y,x) - 127) * (sX.at<uchar>(y,x) - 127)
//                                                               + (sY.at<uchar>(y,x) - 127) * (sY.at<uchar>(y,x) - 127) ) );
//    cv::threshold(value,value,threshold,0,CV_THRESH_TOZERO);
//}

//void Detector::normalMap(Mat &value, double scale) const
//{
//    static Mat sX = Mat::zeros( value.size(), CV_8U );
//    static Mat sY = Mat::zeros( value.size(), CV_8U );
//    Mat kernX = (Mat_<char>(3,3) <<
//                 -1,  0 , 1,
//                 -2,  0,  2,
//                 -1, -0 , 1);
//    Mat kernY = (Mat_<char>(3,3) <<
//                 1,  2,  1,
//                 0,  0,  0,
//                 -1, -2, -1);
//    cvtColor(value,sX,CV_BGR2GRAY);
//    cvtColor(value,sY,CV_BGR2GRAY);
//    filter2D(sX,sX,0,kernX,Point(-1,-1),127);
//    filter2D(sY,sY,0,kernY,Point(-1,-1),127);
//    for( int y = 0; y < value.rows; y++ ) {
//        for( int x = 0; x < value.cols; x++ ) {
//            value.at<Vec3b>(y,x)[0] = 255;
//            value.at<Vec3b>(y,x)[1] = saturate_cast<uchar>(sY.at<uchar>(y,x));
//            value.at<Vec3b>(y,x)[2] = saturate_cast<uchar>(sX.at<uchar>(y,x));
//        }
//    }
//}

//void Detector::laplacian(Mat &value)
//{
//    Mat kern = (Mat_<char>(3,3) <<
//                0, 1 , 0,
//                1,  -4, 1,
//                0, 1 , 0);
//    cvtColor(value,value,CV_BGR2GRAY);
//    GaussianBlur(value,value,Size(3,3),1.5,1.5);
//    filter2D(value,value,0,kern);
//}





////    cvtColor(oldframe,oldframe,CV_GRAY2BGR);
////    cvtColor(frame,frame,CV_GRAY2BGR);


////    static int mod = 0;
////    static bool b = false;
////    mod++;
////    if(mod % 100 == 0)
////        b = !b;

////      sobel(_frame,1,0);
////    if(b)

////    laplacian(_frame);

////    Mat copie;
////    cvtColor(_frame,_frame,CV_BGR2GRAY);
////    Scharr(_frame,_frame,0,1,0);

////     bilateralFilter(_frame,copie,0,1,1);
////     sobel(_frame,1,0);

////      GaussianBlur(_frame,_frame,Size(3,3),1.5,1.5);
////      sobel(_frame,1,0);
////      Mat element = getStructuringElement( MORPH_ELLIPSE,
////                                           Size( 2 + 1, 2 + 1 ),
////                                           Point( 2, 2 ) );
//////      dilate(_frame, _frame, element );
////      threshold(_frame,_frame,0,100,CV_THRESH_TOZERO);



////    else
////      traitement(_frame);

////    contrast(_frame,8,0);
//// GaussianBlur(_frame,_frame,Size(3,3),1.5,1.5);
////    normalMap(_frame,10);

////    cvtColor(_frame,_frame,CV_BGR2GRAY);
////    GaussianBlur(_frame,_frame,Size(9,9),4.5,4.5);
////    Sobel(_frame,_frame,0,1,1,1);

////

////    integral(_frame,_frame);

////        contrast(_frame,4,0);

////    toLab(_frame,_frame);
////    colorTraitement(_frame);
////            traitement(_frame);
////    flip(_frame,_frame,1);
